﻿#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <math.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>
#include "add.h"
//#include <iostream>
#pragma region 数组
void bubblesort(int arr[],int length)
{
	for (int i = 0; i < length - 1; i++)
	{
		int flag = 1;
		for (int j = 0; j < length-1-i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int t = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = t;
				flag = 0;
			}
		}
		if (flag)
		{
			break;
		}
	}
}
int main()
{
	//二维数组 行可以省略 列不可以省略
	/*int arr[] = { 1,2,3 };
	int len = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	for (i = 0; i < len; i++)
	{
		printf("arr[%d]=%p\n", i, &arr[i]);
	}*/
	//char arr1[] = "abc";
	//printf("%d\n", sizeof(arr));//12
	//printf("%d\n", sizeof(arr1));//4
	/*int arr[][4] = { 1,2,3,4,5,6,7,8 };
	printf("%d\n", sizeof(arr) / sizeof(arr[0]));
	printf("%d\n", sizeof(arr[0]) / sizeof(arr[0][0]));*/
	/*int i = 9;
	do {
		i--;
		if (i % 2 == 0)
		{
			continue;
		}
		printf("%d\n", i);
	} while (i > 0);*/
	/*if (1)
		break;*/
	//break 语句只能在循环或开关中使用

	int arr[] = { 90,86,67,35 };
	printf("%p\n", arr);//数组首元素的地址
	printf("%p\n", arr+1);//数组第二个元素的地址 也就是下标为1的元素的地址
	printf("%p\n", &arr[0]);//数组首元素的地址
	printf("%p\n", &arr[0]+1);//数组第二个元素的地址 也就是下标为1的元素的地址
	printf("%p\n", &arr);//整个数组的地址
	printf("%p\n", &arr+1);//数组下一个元素的地址
	printf("%d\n", *arr);
	int length = sizeof(arr) / sizeof(arr[0]);
	bubblesort(arr, length);
	for (int i = 0; i < length; i++)
	{
		printf("%d ", arr[i]);
	}
	int a = 127;
	int b = a + 1;
	printf("%d\n", b);
	return 0;
}
#pragma endregion

#pragma region 递归之斐波那契数列的计算
//int fib1(int n)
//{
//	if (n <= 2) 
//	{
//		return 1;
//	}
//	return fib1(n - 1) + fib1(n - 2);
//}
//int fib2(int n)
//{
//	int a = 1;
//	int b = 1;
//	int c = 1;
//	//for (int i = 3; i <= n; i++)
//	//{
//	//	c = a + b;//0
//	//	a = b;//1
//	//	b = c;//1
//	//}
//	while (n > 2)
//	{
//		c = a + b;//0
//		a = b;//1
//		b = c;//1
//		n--;
//	}
//	return c;
//}
//int main()
//{
//	//  ret(n-1+n-2) a b c 
//	//  a = 1+0；
//	//  c = a+b
//	//  b = a
//	//  5 = 3+2
//	//1 1 2 3 5 8 13 21 34 55 89....
//	//a b c
//	int n = 5;
//	//int ret = fib1(10);
//	int ret = fib2(n);
//	
//	printf("%d\n", ret);
//	return 0;
//}
#pragma endregion

#pragma region 递归之计算阶乘
/*
	递归：
	程序调用自身的编程技巧称为递归（recursion）
	递归作为一种算法在程序设计语言中广泛应用。
	一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为
	一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可以描述出解题过程所需要的多次重复计算
	大大减少了程序的代码量。递归的主要思考方式在于把大事化小，把小事化无
	递归存在的两个必要条件：
	1.存在限制条件，当满足限制条件的时候，递归变不再继续。
	2.每次递归调用之后越来越接近这个限制条件
	肾虚,有时是在过度劳累之后,腰腿酸痛,精神不振,好像身体被掏空
*/
//int Fan1(int n)
//{
//	int ret = 1;
//	for (int i = 1; i <= 5; i++)
//	{
//		ret = ret * i;
//	}
//	return ret;
//}
//int Fan2(int n)
//{
//	if (n <= 1)
//	{
//		return 1;
//	}
//	return n * Fan2(n - 1);
//}
//int main()
//{
//	//1! = 1*1
//	//2! = 2*(2-1)
//	//3! = 3*(3-2)*(2-1) ...
//	//5! = 5*4*3*2*1 斐波那契数列 1 1 2 3 5 8 13 
//	int n = 5;
//	int ret = Fan2(5);
//	printf("%d\n", ret);
//	return 0;
//}
#pragma endregion

#pragma region 递归之求取字符串的长度
/*
	递归：
	程序调用自身的编程技巧称为递归（recursion）
	递归作为一种算法在程序设计语言中广泛应用。
	一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为
	一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可以描述出解题过程所需要的多次重复计算
	大大减少了程序的代码量。递归的主要思考方式在于把大事化小，把小事化无
	递归存在的两个必要条件：
	1.存在限制条件，当满足限制条件的时候，递归变不再继续。
	2.每次递归调用之后越来越接近这个限制条件
	肾虚,有时是在过度劳累之后,腰腿酸痛,精神不振,好像身体被掏空
*/
//int mystrlen(char* str)
//{
//	//不使用递归
//	int count = 0;
//	while (*str != '\0')
//	{
//		count++;
//		str++;
//	}
//	return count;
//}

//int mystrlen(char* s)
//{
//	if (*s != '\0')
//	{
//		return 1 + mystrlen(s + 1);
//	}
//	return 0;
//}
//int main()
//{
//	char str[] = "Hello,World!!";
//	//int len = strlen(str);//11
//	int len = mystrlen(str);
//	printf("%d\n", len);
//	return 0;
//}
#pragma endregion

#pragma region 递归 之 将数字倒序输出到控制台
/*
	递归：
	程序调用自身的编程技巧称为递归（recursion）
	递归作为一种算法在程序设计语言中广泛应用。
	一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为
	一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可以描述出解题过程所需要的多次重复计算
	大大减少了程序的代码量。递归的主要思考方式在于把大事化小，把小事化无
	递归存在的两个必要条件：
	1.存在限制条件，当满足限制条件的时候，递归变不再继续。
	2.每次递归调用之后越来越接近这个限制条件
	肾虚,有时是在过度劳累之后,腰腿酸痛,精神不振,好像身体被掏空
*/
//int i = 0;
//void print(int n)
//{
//	
//	printf("%d", n%10);
//	if (n > 9)
//	{
//		//n /= 10;
//		//调用自身函数
//		print(n/10);
//	}
//}
//int main() 
//{
//	//
//	/*i++;
//	printf("He he \n");
//	if (i >= 100) return;
//	main();*/
//	int num = 1234;
//	/*while(num > 0)
//	{
//		printf("%d", num % 10);
//		num /= 10;
//	}*/
//	print(num);
//	return 0;
//}
#pragma endregion

#pragma region 函数之头文件
//int main()
//{
//	/*int a = 3;
//	int b = 5;
//	int sum = Add(a, b);
//	printf("%d\n", sum);*/
//	//		i	4294967286	unsigned int
//	/*unsigned int  i = 10;
//	i = -10;
//	printf("%d\n", i);
//	for (i; i >= 0; i--)
//	{
//		printf("@_@<-->@_@\n");
//	}
//
//	printf("end\n");*/
//	int a[10], n;
//	for (n = 0; n <= 10; n++) {
//		a[n] = n - 10;
//		printf("%d\n", a[n]);
//	}
//	printf("end\n");
//	return 0;
//}
#pragma endregion

#pragma region 输出特殊图案
//int main()
//{
//	/*char a = 32, b = 33;
//	printf("%c%c%c%c%c\n", b, a, a, a, b);
//	printf("%c%c%c%c%c\n", a, b, a, b, a);
//	printf("%c%c%c%c%c\n", a, a, b, a, a);
//	printf("%c%c%c%c%c\n", a, b, a, b, a);
//	printf("%c%c%c%c%c\n", b, a, a, a, b);*/
//	int i, j;
//
//	printf("11\n"); /*输出11来表示两个笑脸*/
//
//	for (i = 1;i < 11;i++)
//	{
//		for (j = 1;j <= i;j++)
//			printf("%c%c", 70, 70);
//		printf("\n");
//	}
//	return 0;
//}
#pragma endregion

#pragma region 指针
//int main()
//{
//	//数组名代表数组首元素的地址
//	//数组名相当于指向数组第一个元素的指针
//	/*int arr[] = { 10,11,12,13,24 };
//	printf("%d\n", arr);
//	printf("%x\n", *arr);
//	printf("%d\n", &arr[0]);
//	printf("%d\n", arr[0]);*/
//	/*
//	  说明：若a是指向数组第一个元素的指针，即a相当于&a[0]
//	  &a是指向数组的指针，&a+1将跨越数组元素个数*4个字节
//		&a 相当于管辖范围“上升”了一级
//	  *a是数组的第一个元素a[0] 即*a等价于a[0]
//		*a 相当于管辖范围“下降”了一级
//		数组名相当于指向数组第一个元素的指针
//		&a 相当于把a管辖范围“上升”了一个级别
//		*a 相当于把a管辖范围“下降”了一个级别
//	*/
//	//int a[5] = { 10,3,5,7,15 };
//	//printf("%x\n", a);
//	//printf("%x\n", *a);
//	//printf("%x\n", a+1);
//	//printf("%x\n", &a);
//	//printf("%x\n", &a+1);//跨越20个字节
//	//printf("%x\n", *(&a));
//	//printf("%x\n", *(&a)+1);
//	return 0;
//}
#pragma endregion

#pragma region 递归应用之逆波兰表达式 四星半
//double notation()
//{
//	char str[10];
//	scanf("%s", str);
//	switch (str[0])
//	{
//	case '+':return notation() + notation();
//	case '-':return notation() - notation();
//	case '*':return notation() * notation();
//	case '/':return notation() / notation();
//	default:return atof(str);
//	}
//}
//int main()
//{
//	double d = notation();
//	printf("%f", d);
//	return 0;
//}
#pragma endregion

#pragma region 递归应用之切饼
//int q(int n)
//{
//	if (n == 0)return 1;
//	else return n + q(n - 1);
//}
//int main()
//{
//	printf("%d", q(4));
//	return 0;
//}
#pragma endregion

#pragma region 递归应用之斐波那契数列
//int f(int n)
//{
//	if (n == 1)return 1;
//	if (n == 2)return 1;
//	else return f(n - 1) + f(n - 2);
//}
//int main()
//{
//	for (int i = 1; i < 10; i++)
//	{
//		printf("%d ", f(i));
//	}
//	return 0;
//}
#pragma endregion

#pragma region 递归应用之进制转换
//void convert(int x)
//{
//	if (x / 2 != 0)
//	{
//		convert(x / 2);
//		printf("%d", x % 2);
//	}
//	else 
//	{
//		printf("%d", x);
//	}
//}
//int main()
//{
//	int i = 123;
//	printf("将十进制的数字转换二进制是：\n");
//	convert(i);
//	return 0;
//}
#pragma endregion

#pragma region 递归应用之放苹果
/*
	把M个同样的苹果放在N个同样的盘子里，允许有的盘子空着不放，问共有多少种不同的分法
*/
//int count(int m, int n)
//{
//	if (m <= 1 || n <= 1)return 1;
//	if (m < n) 
//	{
//		return count(m, m);
//	}
//	else
//	{
//		return count(m, n - 1) + count(m - n, n);
//	}
//}
//int main()
//{
//	int apples, plates;
//	printf("请输入苹果的数量：");
//	scanf("%d", &apples);
//	printf("请输入盘子的数量：");
//	scanf("%d", &plates);
//	int c = count(apples, plates);
//	printf("共有%d中分法", c);
//	return 0;
//}
#pragma endregion

#pragma region 递归应用之汉诺塔问题
//void move(int m, char x, char y, char z)
//{
//	if (m == 1)
//	{
//		printf("把一个盘子从%c移动到%c\n", x, z);
//	}
//	else
//	{
//		move(m - 1, x, z, y);
//		printf("把一个盘子从%c移动到%c\n", x, z);
//		move(m - 1, y, x, z);
//	}
//}
//int main()
//{
//	int n = 0;
//	printf("请输入盘子数：");
//	scanf("%d", &n);
//	printf("在3根柱子上移动%d个盘子的步骤是：\n",n);
//	move(n, 'A', 'B', 'C');
//	return 0;
//}
#pragma endregion
#pragma region 数字统计 示例1 输入20个 0-9 之间的整数 请你统计每个数在输入的数列中出现的次数
/*
	第一种方式：
	输入20个0-9之间的整数 请你统计每个数在输入的数列中出现的次数
*/
//int main()
//{
//
//	int num, count[10] = { 0 };
//	for (int i = 0; i < 20; i++)
//	{
//		scanf("%d", &num);
//		for (int j = 0; j < 10; j++)
//		{
//			if (num == j)
//			{
//				count[j]++;
//			}
//		}
//	}
//	for (int i = 0; i < 10; i++)
//	{
//		if (count[i] != 0)
//		{
//			printf("%d输入了%d次\n", i, count[i]);
//		}
//	}
//	return 0;
//}

/*
	第二种方式
*/
//int main()
//{
//	printf("请 输入20个 0-9 之间的整数\n");
//	int num, count[10] = { 0 };
//	for (int i = 0; i < 20; i++)
//	{
//		scanf("%d", &num);
//		switch (num)
//		{
//		case 0:
//			count[0]++;
//			break;
//		case 1:
//			count[1]++;
//			break;
//		case 2:
//			count[2]++;
//			break;
//		case 3:
//			count[3]++;
//			break;
//		case 4:
//			count[4]++;
//			break;
//		case 5:
//			count[5]++;
//			break;
//		case 6:
//			count[6]++;
//			break;
//		case 7:
//			count[7]++;
//			break;
//		case 8:
//			count[8]++;
//			break;
//		default:
//			count[9]++;
//			break;
//		}
//	}
//	for (int i = 0; i < 10; i++)
//	{
//		if (count[i] != 0) 
//		{
//			printf("%d输入了%d次\n", i, count[i]);
//		}
//	}
//	return 0;
//}

/*
  第三种方式
*/
//int main()
//{
//	printf("请 输入20个 0-9 之间的整数\n");
//	int num, count[10] = { 0 };
//	for (int i = 0; i < 20; i++)
//	{
//		scanf("%d", &num);
//		count[num]++;
//	}
//	for (int i = 0; i < 10; i++)
//	{
//		if (count[i] != 0)
//		{
//			printf("%d输入了%d次\n", i, count[i]);
//		}
//	}
//	return 0;
//}
#pragma endregion

#pragma region MyRegion
//int main()
//{  
//	int arr[4];//数组有默认值
//	int arr1[] = { 1,2,3 };
//	//int a;
//	printf("%d", sizeof(arr1)/sizeof(arr1[0]));
//	return 0;
//}
#pragma endregion

#pragma region do while循环示例演示
/*
	输入一个数字，反向输出并求出这个数字的位数
*/
//int main()
//{
//	int num = 0,count = 0;
//	scanf("%d", &num);
//	do {
//		printf("%d", num % 10);
//		num /= 10;
//		count++;
//	} while (num != 0);
//	printf("\n%d", count);
//	return 0;
//}
#pragma endregion

#pragma region while循环示例演示
/*
	小红10岁，小红的父亲33岁，问多少年后，父亲的年龄是小红的2倍
*/
//int main()
//{
//	int ageOfXiao = 10;//23
//	int ageOfFather = 33;//46
//	int count = 0;
//	while (2*ageOfXiao != ageOfFather)
//	{
//		ageOfXiao++;
//		ageOfFather++;
//		count++;
//	}
//	printf("经过%d年后，小红父亲的年龄是小红的2倍\n", count);
//	return 0;
//}
#pragma endregion

#pragma region switch示例
/*
	学校要求实行成绩等级制度。按照百分制成绩输出对应的等级成绩：
	90-100 为 A  80-90 为 B 70-80 为 C 60-70 为 D 60分以下为E    
*/
//int main()
//{
//	int score = 100;
//	int num = score / 10;
//	switch (num)
//	{
//	case 10:
//	case 9:
//		printf("A\n");
//		break;
//	case 8:
//		printf("B\n");
//		break;
//	case 7:
//		printf("C\n");
//		break;
//	case 6:
//		printf("D\n");
//		break;
//	default:
//		printf("E\n");
//		break;
//	}
//	return 0;
//}
#pragma endregion

#pragma region 如何快速的掌握一门编程语言
/*
	语言的种类千差万别，但是，一般来说，基本成分不外四种：
	1. 数据成分：用于描述程序中所涉及的数据
		有哪些数据类型，如何使用
	2. 运算成分：用于描述程序中所包含的运算
		有哪些运算符号，如何使用
	3. 控制成分：用于描述程序中的控制构造
		三种类型的控制语句是如何写的
	4. 传输成分：用于表达程序中的数据传输
		在程序中如何输入和输出数据
*/
//int main()
//{
//	//在c语言中 当最高位是1其它位是0（-0）时，最高位即表示负号，也表示整数最高位1
//	//int a;
//	char a = 6 + 256;
//	//bool b = false;
//	printf("\a");
//	return 0;
//}
#pragma endregion

#pragma region 输入10个 0-100 之间的不同整数 彼此以空格分隔 重新排序以后输出（也按空格分隔）
//要求：1. 先输出其中的奇数 并按从大到小排列
//要求：2. 然后输出其中的奇数 并按从小到大排列
// 写程序的过程：
// 按照由大到小 由粗到精 由抽象到具体的方法分析、编写程序
// 程序的结构：
// 程序由若干个“模块”组成
// 模块之内高内聚（一个模块只负责一个功能）
// 模块之间松耦合（模块之间不存在相互依赖关系，当一个模块修改时不会影响其他的模块）
// 这是结构化程序设计的基本思想
//int main()
//{
//	int arr[10] = { 0 };
//	printf("请输入10个数字，以空格分隔：\n");
//	int length = sizeof(arr) / sizeof(arr[0]);
//	for (int i = 0; i < length; i++)
//	{
//		scanf("%d", &arr[i]);
//	}
//	printf("您输入的10个数字分别是：\n");
//	for (int i = 0; i < length; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//	printf("\n");
//	int odd[10], even[10];
//	int oddIndex = 0;
//	int evenIndex = 0;
//	for (int i = 0; i < length; i++)
//	{
//		if(arr[i] % 2 != 0)
//		{
//			odd[oddIndex] = arr[i];
//			oddIndex++;
//		}
//		else
//		{
//			even[evenIndex] = arr[i];
//			evenIndex++;
//		}
//	}
//	printf("您输入的10个数字奇数分别是：\n");
//	for (int i = 0; i < oddIndex; i++)
//	{
//		printf("%d ", odd[i]);
//	}
//	printf("\n");
//	printf("您输入的10个数字偶数分别是：\n");
//	for (int i = 0; i < evenIndex; i++)
//	{
//		printf("%d ", even[i]);
//	}
//	printf("\n");
//
//	//使用选择排序 对奇数数组从大到小排列
//	for (int i = 0; i < oddIndex - 1; i++)
//	{
//		for (int j = i+1; j < oddIndex; j++)
//		{
//			if (odd[j] > odd[i])
//			{
//				int t = odd[j];
//				odd[j] = odd[i];
//				odd[i] = t;
//			}
//		}
//	}
//	printf("奇数排序后的结果是：\n");
//	for (int i = 0; i < oddIndex; i++)
//	{
//		printf("%d ", odd[i]);
//	}
//	printf("\n");
//	//使用选择排序 对偶数数组从小到大排列
//	for (int i = 0; i < evenIndex - 1; i++)
//	{
//		for (int j = i + 1; j < evenIndex; j++)
//		{
//			if (even[j] < even[i])
//			{
//				int t = even[j];
//				even[j] = even[i];
//				even[i] = t;
//			}
//		}
//	}
//	printf("偶数排序后的结果是：\n");
//	for (int i = 0; i < evenIndex; i++)
//	{
//		printf("%d ", even[i]);
//	}
//	printf("\n");
//	return 0;
//}
#pragma endregion

#pragma region 演示选择排序
//int main()
//{
//	//1  16,25,9,90,23 j=i+1 j<5
//	//1  25,16,9,90,23
//	//1  90,16,9,25,23
//
//	//2  90,16,9,25,23
//	//2  90,25,9,16,23
//
//	//3  90,25,9,16,23
//	//3  90,25,16,9,23
//	//3  90,25,23,9,16
//
//	//4  90,25,23,16,9
//	int arr[5] = { 16,25,9,90,23 };
//	int length = sizeof(arr) / sizeof(arr[0]);
//	for (int i = 0; i < length - 1; i++)
//	{
//		for (int j = i+1; j < length; j++)
//		{
//			if (arr[j] > arr[i])
//			{
//				int t = arr[j];
//				arr[j] = arr[i];
//				arr[i] = t;
//			}
//		}
//	}
//	printf("使用选择排序完成之后是：\n");
//	for (int i = 0; i < length; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//
//}
#pragma endregion

#pragma region 演示冒泡排序
//int main()
//{
//	int arr[5] = { 16,25,9,90,23 };
//	int length = sizeof(arr) / sizeof(arr[0]);
//	for (int i = 0; i < length - 1; i++)
//	{
//		for (int j = 0; j < length-1-i; j++)
//		{
//			if (arr[j] > arr[j + 1])
//			{
//				int t = arr[j];
//				arr[j] = arr[j + 1];
//				arr[j + 1] = t;
//			}
//		}
//	}
//	printf("使用冒泡排序完成之后是：\n");
//	for (int i = 0; i < length; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//	return 0;
//}
#pragma endregion

#pragma region 值传递和指针传递 交换两个变量的值
//值传递
//void Swap1(int a, int b)
//{
//	int t = a;
//	a = b;
//	b = t;
//}
////地址传递 指针传递
//void Swap2(int* a, int* b)
//{
//	int t = *a;
//	*a = *b;
//	*b = t;
//}
//int main()
//{
//	int a = 10;
//	int b = 20;
//	//Swap1(a, b);
//	Swap2(&a, &b);
//	printf("a=%d\nb=%d\n", a, b);
//	return 0;
//}
#pragma endregion

#pragma region 函数
//int main()
//{
//	char arr1[] = "bdqn";
//	char arr2[] = "#####";
//	strcpy(arr2, arr1);
//	printf("%s\n", arr2);
//	return 0;
//}
#pragma endregion

#pragma region 一个关于我是猪的关机小程序 演示goto 可以使用循环代替
//int main()
//{
//	char input[20] = { 0 };
//	system("shutdown -s");
//again:
//	printf("请注意电脑在1分钟之后关机，若不想关机，输入：我是猪\n请输入>:");
//	scanf("%s", &input);
//	if (strcmp(input, "我是猪") == 0)
//	{
//		system("shutdown -a");
//	}
//	else
//	{
//		goto again;
//	}
//	return 0;
//}
//使用循环代替
//int main()
//{
//	char input[20] = { 0 };
//	system("shutdown -s -t 5");
//	while (1)
//	{
//		printf("请注意电脑在1分钟之后关机，若不想关机，输入：我是猪\n请输入>:");
//		scanf("%s", input);
//		if (strcmp(input, "我是猪") == 0)
//		{
//			system("shutdown -a");
//			break;
//		}
//	}
//	return 0;
//}
#pragma endregion

#pragma region 猜数字小游戏
/*
* 显示主菜单
*/
//void menu()
//{
//	printf("********************************************\n");
//	printf("********* 1.Play      0.Exit      **********\n");
//	printf("********************************************\n");
//}
//void game()
//{
//	//0-32767
//	int ret = rand()%100 + 1;
//	//printf("%d\n", ret);
//	
//	int guess = 0;
//	while (1)
//	{
//		printf("请输入你要猜的数字(1-100)：");
//		scanf("%d", &guess);
//		if (guess > ret)
//		{
//			printf("猜大了\n");
//		}
//		else if (guess < ret)
//		{
//			printf("猜小了\n");
//		}
//		else 
//		{
//			printf("恭喜你猜对了\n");
//			break;
//		}
//	}
//}
//int main()
//{
//	int input = 0;
//	do
//	{
//		menu();
//		//生成随机数
//		srand((unsigned)time(NULL));
//		printf("请输入1或者0：");
//		scanf("%d", &input);
//		switch (input)
//		{
//		case 1:
//			game();
//			break;
//		case 0:
//			printf("退出游戏！！\n");
//			break;
//		default:
//			printf("输入有误！！\n");
//			break;
//		}
//
//	} while (input);
//	return 0;
//}
#pragma endregion

#pragma region 求最大值
//求10个数的最大值
//int main()
//{
//	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
//	int max = arr[0];
//	int len = sizeof(arr) / sizeof(arr[0]);
//	for (int i = 1; i < len; i++)
//	{
//		if (arr[i] > max) 
//		{
//			max = arr[i];
//		}
//	}
//	printf("max=%d\n", max);
//	return 0;
//}
#pragma endregion

#pragma region 分数求和
//计算1/1-1/2+1/3-1/4+1/5-1/6+.......+1/99-1/100的值，打印出结果
//int main()
//{
//	//第一种方式
//	//int i = 0;
//	//double sum = 0;
//	//int flag = 1;
//	//for (i = 1; i <= 100; i++)
//	//{
//	//	//秒啊
//	//	sum += flag*1.0 / i;
//	//	flag = -flag;
//	//}
//	//printf("sum=%lf\n", sum);
//	
//	//第二种方式
//	double odd = 0;//奇数
//	double even = 0;//偶数
//	for (int i = 1; i <= 100; i+=2)
//	{
//		odd += 1.0 / i;
//	}
//	for (int i = 2; i <= 100; i+=2)
//	{
//		even += 1.0 / i;
//	}
//	double sum = odd - even;
//	printf("sum=%lf\n", sum);
//	return 0;
//}
#pragma endregion

#pragma region 数9的个数
//编写程序数一下 1-100的所有的整数中出现多个数字9
//int main()
//{
//	int i = 0;
//	int count = 0;
//	for (i = 1; i <= 100; i++)
//	{
//		//个位是9
//		if (i % 10 == 9)
//		{
//			count++;
//		}
//		//十位是9
//		if (i / 10 == 9)
//		{
//			count++;
//		}
//	}
//	printf("1-100之间共有%d个数字出现9",count);
//	return 0;
//}

#pragma endregion

#pragma region 打印1-100 之间的质数（素数）
//求质数用到开平方根的函数时，记得引入math.h
//质数：指在大于1的自然数中,除了1和它本身之外不能被任何数整除的数为质数
//int main()
//{
//	int i = 2;
//	printf("质数有：\n");
//	//printf("%d", sqrt(100));
//	for (i = 2; i < 100; i++)
//	{
//		int flag = 1;//立个标志假设为质数
//		//16 = 2*8 4*4  36
//		//for (int j = 2; j <= i/2; j++)
//		for (int j = 2; j <= sqrt(i); j++)
//		{
//			if (i % j == 0)
//			{
//				flag = 0;
//				break;
//			}
//		}
//		if (flag)
//		{
//			printf("%d ",i);
//		}
//	}
//	return 0;
//}

/*
  第二种方式 筛法求素数
//*/
//int main()
//{
//	int sum = 0, arr[100] = { 0 };
//	for (int i = 2; i < sqrt(100.0); i++)
//	{
//		sum = i;
//		if (arr[sum] == 0)
//		{
//			while (sum < 100)
//			{
//				sum += i;
//				if (sum < 100)
//				{
//					arr[sum] = 1;
//				}
//			}
//		}		
//	}
//	printf("1-100之间的素数有：\n");
//	for (int i = 2; i < 100; i++)
//	{
//		if (arr[i] == 0)
//		{
//			printf("%d ", i);
//		}
//	}
//	return 0;
//}
#pragma endregion

#pragma region 打印1000-2100 之间的闰年
//闰年的计算规则是能被4整除并且不能被100整除 或者 能被400整除
//int main()
//{
//	int year = 0;
//	printf("闰年有：\n");
//	for (year = 1000;year <= 2100; year++)
//	{
//		if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
//		{
//			printf("%d ", year);
//		}
//	}
//	return 0;
//}
#pragma endregion

#pragma region 使用嵌套循环打印99乘法表
//int main()
//{
//	for (int i = 1; i < 10; i++)
//	{
//		for (int j = 1; j <= i; j++)
//		{
//			//printf("%d*%d=%-2d\t", j, i, j * i);
//			printf("%d*%d=%d\t", j, i, j * i);
//		}
//		printf("\n");
//	}
//	return 0;
//}
#pragma endregion

#pragma region 求两个数的最大公约数
//int main()
//{
//	int m = 24;
//	int n = 18;
//	int r = 0;
//	while (r = m % n)
//	{
//		//int r = m % n;
//		m = n;
//		n = r;
//	}
//	printf("最大公约数是：%d", n);
//	return 0;
//}
#pragma endregion

#pragma region 简单3个数的排序
//int main()
//{
//    int a = 0;
//    int b = 0;
//    int c = 0;
//    scanf("%d%d%d", &a, &b, &c);
//    if (a < b)
//    {
//        int t = a;
//        a = b;
//        b = t;//t得a a得b b得t
//    }
//    if (a < c)
//    {
//        int t = a;
//        a = c;
//        c = t;
//    }
//    if (b < c)
//    {
//        int t = b;
//        b = c;
//        c = t;
//    }
//    printf("%d%d%d", a, b, c);
//    return 0;
//}
#pragma endregion

#pragma region 演示动态转换字符(多个字符从两端移动 向中间汇聚)
//int main()
//{
//	//编写代码 演示多个字符从两端移动 向中间汇聚
//	char arr1[] = "Welcome to Yuncheng Bei Da Qing Niao ! ! ! ! ! !";
//	char arr2[] = "################################################";
//	int left = 0;
//	int right = strlen(arr1) - 1;
//	while (left <= right)
//	{
//		arr2[left] = arr1[left];
//		arr2[right] = arr1[right];
//		printf("%s\n", arr2);
//		Sleep(1000);
//		//system("cls");
//		left++;
//		right--;
//	}
//	return 0;
//}
#pragma endregion

#pragma region 二分查找法(基于元素是按照升序排列的)
//编写代码在一个整型有序数组中查找具体的某个数
//要求：找到了就打印数字所在的下标，找不到，则输出找不到
//int main()
//{
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	int num = 8;
//	//计算数组的长度
//	int len = sizeof(arr) / sizeof(arr[0]);
//	//使用二分查找法 查找元素的下标
//	int left = 0;
//	int right = len - 1;
//	while (left <= right)
//	{
//		int mid = (left + right) / 2;
//		if (arr[mid] > num)
//		{
//			right = mid - 1;
//		}
//		else if (arr[mid] < num)
//		{
//			left = mid + 1;
//		}
//		else
//		{
//			printf("找到了，元素下标是：%d\n", mid);
//			break;
//		}
//	}
//	if (left > right) 
//	{
//		printf("没找到该元素\n");
//	}
//	/*int i;
//	for (i = 0; i < len; i++)
//	{
//		if (num == arr[i])
//		{
//			printf("找到了，元素下表是：%d\n", i);
//			break;
//		}
//	}
//	if (i == len)
//	{
//		printf("没找到！！\n");
//	}*/
//	return 0;
//}
#pragma endregion

#pragma region 计算阶乘
//定义宏
//#define add(x,y) x+y
//int main()
//{
//	int sum = 0;
//	
//	int n = 4;
//	int ret = 1;
//	for (int i = 1; i <= n; i++)
//	{
//		ret *= i;		
//		printf("%d\n", ret);
//		sum += ret;
//	}
//	
//	printf("%d\n",sum);
//	//int ch = 0;
//	////EOF End Of File文件结束标志 -1
//	//while ((ch = getchar()) != EOF)
//	//{
//	//	putchar(ch);
//	//}
//	//打印99乘法表
//	/*for (int i = 1; i < 10; i++)
//	{
//		for (int j = 1; j <= i; j++)
//		{
//			printf("%d*%d=%d\t", j, i, j * i);
//		}
//		printf("\n");
//	}*/
//}
//int main()
//{
//	int n = 1;
//	int m = 2;
//	switch (n)
//	{
//	case 1:
//		m++;
//	case 2:
//		n++;
//	case 3:
//		switch (n)
//		{
//		case 1:
//			n++;
//		case 2:
//			m++;//4
//			n++;//3
//			break;//break只跳出一套switch
//		}
//	case 4:
//		m++;//5
//		break;
//	default:
//		break;
//	}
//	//5 3
//	printf("m=%d n=%d\n", m, n);
//	return 0;
//}
//代码判断条件一定要反着写
//int main()
//{
//	//c语言中 0为假 非0为真
//	int x = 3;
//	//if (x = 5)//C语言是可以允许在if表达式之后赋值的
//	//因此判断条件的时候一定要先将常量放在前面
//	//常量放在左边 形式上更优一些
//	if (5 == x)//C语言是可以允许在if表达式之后赋值的
//	{
//		printf("he he\n");
//	}
//}
// 悬空else
// 顺序结构：生老病死 
// 分支结构：人生境遇不同
// 循环结构：轮回
//int main()
//{
//	int a = 0;
//	int b = 1;
//	if (a == 1)
//		if(b == 1)
//		printf("He he!!\n");
//		else
//	printf("Ha 哈!!\n");
//	return 0;
//}
//struct Book
//{
//	char name[20];
//	int price;
//};
//int main()
//{
//	//结构化程序语言：顺序结构 分支（选择）结构 循环结构
//	
//	struct Book b = { "c语言程序设计",21 };
//	struct Book* p = &b;
//	strcpy(p->name , "Java语言");
//	//指针类型变量使用->属性 获取该值
//	printf("%s\n", p->name);
//	//extern int g_val;
//	/*int a = 10;
//	int b = 30;
//	int c = add(a, b);
//	printf("%d", c);*/
//	//00100000 11111001 11011100
//	//00100010 11110111 10110100
//	//20F9DC
//	//int a = 10;
//	////*为指针类型
//	//int* p = &a;
//	////*指针类型变量 为解引用 找到某个变量的地址
//	//*p = 20;
//	printf("%d\n", sizeof(char *));
//	return 0;
//}
//void test()
//{	
//	static int a = 1;
//	a++;
//	printf("a=%d\n", a);
//}
//int main()
//{
//	int i = 0;
//	while (i++ < 5) {
//		test();
//	}
//	return 0;
//}
//int main()
//{
//	//只要是整数 内存中存储的都是二进制补码 正数以0开头 负数以1（表示符号位）开头
//	//正数：原码                反码                补码 都是一样的
//	//负数：原码（直接按照正负写出来的二进制序列）
//	//          反码（原码的符号位不变，其他位取反得到）
//	//          补码（反码加1得到）
//	//0111 1111 | 1111 1111 | 1111 1111 | 1111 1111 = 2^31-1
//	//1000 0000 | 0000 0000 | 0000 0000 | 0000 0000 
//	//1111 1111 | 1111 1111 | 1111 1111 | 1111 1111 反码
//	//1000 0000 | 0000 0000 | 0000 0000 | 0000 0000 补码
//	//-2^31
//	return 0;
//}
//int main()
//{
//	int i = 10;
//	/*char name[100];
//	printf("目标：");
//	scanf_s("%s", &name, 40);*/
//	/*printf("次数：");
//	scanf_s("%d", &i);*/
//	HWND H = FindWindow(L"WeChatMainWndForPC", L"WeChat");	//寻找对话框 
//	SetForegroundWindow(H);
//	
//	while (i-- > 0) {
//		keybd_event(VK_CONTROL, 0, 0, 0);	//粘贴 
//		keybd_event('V', 0, 0, 0);	//粘贴 
//		keybd_event('V', 0, 2, 0);	//粘贴 
//		keybd_event(VK_CONTROL, 0, 2, 0);	//粘贴 
//		keybd_event(VK_RETURN, 0, 0, 0);//回车 
//		keybd_event(VK_RETURN, 0, 2, 0);//回车 
//     Sleep(1000);
//	}
//	return 0;
//}
//int main()
//{
//	/*char cha[] = "abc";
//	printf("%s\n", cha);*/
//	int a = 3.14;
//	// 00000000 00000000 00000001
//	// 11111111 11111111 11111110 补码
//	// 11111111 11111111 11111101 反码
//	// 10000000 00000000 00000010 原码
//	//-2
//	//int b = ~ a;
//	a = a++;
//	printf("%d\n", a);//-1
//	return 0;
//}
#pragma endregion
